// API环境配置
const getApiConfig = () => {
  // 优先使用环境变量中的配置
  const envBaseUrl = import.meta.env.VITE_API_BASE_URL;
  const envApiPrefix = import.meta.env.VITE_API_PREFIX;
  
  if (envBaseUrl) {
    return {
      baseUrl: envBaseUrl,
      apiPrefix: envApiPrefix || ''
    };
  }
  
  // 如果没有环境变量配置，使用默认配置
  const API_CONFIG = {
    development: {
      baseUrl: 'http://localhost:8080',
      apiPrefix: '/api'
    },
    production: {
      baseUrl: 'http://api.largeq.cn',
      apiPrefix: '/stock'
    }
  };
  
  const env = import.meta.env.MODE || 'development';
  return API_CONFIG[env] || API_CONFIG.development;
};

// 获取当前环境的API配置
const currentConfig = getApiConfig();
const BASE_URL = currentConfig.baseUrl;
const API_PREFIX = currentConfig.apiPrefix;

/**
 * 通用的API请求函数
 * @param {string} endpoint - API端点
 * @param {object} options - 请求选项
 * @returns {Promise} - 返回Promise对象
 */
const apiRequest = async (endpoint, options = {}) => {
  try {
    const response = await fetch(`${BASE_URL}${endpoint}`, {
      headers: {
        'Content-Type': 'application/json',
        ...options.headers,
      },
      ...options,
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const result = await response.json();
    
    if (!result.success) {
      throw new Error(result.message || 'API请求失败');
    }

    return result.data;
  } catch (error) {
    console.error('API请求错误:', error);
    throw error;
  }
};

/**
 * 股票API服务
 */
export const stockApi = {
  /**
   * 获取所有股票列表
   * @param {number} year - 年份（可选）
   * @returns {Promise<Array>} - 股票列表
   */
  async getAllStocks(year) {
    let url = `${API_PREFIX}/stocks-with-reports`;
    if (year) {
      url += `?year=${year}`;
    }
    return await apiRequest(url);
  },

  /**
   * 根据股票代码获取股票详情
   * @param {string} stockCode - 股票代码
   * @returns {Promise<Object>} - 股票详情
   */
  async getStockByCode(stockCode) {
    return await apiRequest(`${API_PREFIX}/stocks/${stockCode}`);
  },

  /**
   * 健康检查
   * @returns {Promise<Object>} - 健康状态
   */
  async healthCheck() {
    try {
      return await apiRequest('/health');
    } catch (error) {
      return { status: 'unhealthy', message: '后端服务未启动' };
    }
  },

  /**
   * 获取服务信息
   * @returns {Promise<Object>} - 服务信息
   */
  async getServiceInfo() {
    return await apiRequest(`${API_PREFIX}/info`);
  },

  /**
   * 获取当前API配置信息
   * @returns {Object} - API配置信息
   */
  getApiConfig() {
    return {
      baseUrl: BASE_URL,
      apiPrefix: API_PREFIX,
      environment: import.meta.env.MODE || 'development'
    };
  }
};

/**
 * 股票数据模型
 */
export const StockModel = {
  /**
   * 格式化股票代码显示
   * @param {string} market - 市场代码
   * @param {string} no - 股票代码
   * @returns {string} - 格式化后的股票代码
   */
  formatStockCode(market, no) {
    return `${market}.${no}`;
  },

  /**
   * 格式化价格显示
   * @param {number} price - 价格
   * @returns {string} - 格式化后的价格
   */
  formatPrice(price) {
    return price ? `¥${price.toFixed(2)}` : '--';
  },

  /**
   * 格式化股本显示
   * @param {number} shares - 股本数量
   * @returns {string} - 格式化后的股本
   */
  formatShares(shares) {
    if (!shares) return '--';
    
    if (shares >= 100000000) {
      return `${(shares / 100000000).toFixed(2)}亿`;
    } else if (shares >= 10000) {
      return `${(shares / 10000).toFixed(2)}万`;
    } else {
      return shares.toString();
    }
  },

  /**
   * 计算涨跌幅
   * @param {number} closePrice - 收盘价
   * @param {number} openPrice - 开盘价
   * @returns {Object} - 涨跌幅信息
   */
  calculateChangeRate(closePrice, openPrice) {
    if (!openPrice || openPrice === 0) return { rate: 0, isPositive: false };
    
    const rate = ((closePrice - openPrice) / openPrice) * 100;
    return {
      rate: Math.abs(rate).toFixed(2),
      isPositive: rate >= 0
    };
  }
};

export default stockApi;